# encoding=utf8
import sys
reload(sys)
sys.setdefaultencoding('utf8')

class JT_8103:
    result=[]
    analysisDescription=['参数总数：','参数ID：','参数长度：','参数值：','']
    #参数总数字段长度
    par_total_num_len=1
    #参数id字段长度
    parid_len=4
    #参数长度字段长度
    par_len_str_len=1
    #参数列表
    par_list=[
        #通讯设置      
        {'id': '0001', 'len': 4, 'des':'终端心跳发送间隔' },
        {'id': '0002', 'len': 4, 'des': 'TCP消息应答超时时间'},
        {'id': '0003', 'len': 4, 'des': 'TCP消息重传次数'},
        {'id': '0004', 'len': 4, 'des': 'UDP消息应答超时时间'},
        {'id': '0005', 'len': 4, 'des': 'UDP消息重传次数'},
        {'id': '0006', 'len': 4, 'des': 'SMS消息应答超时时间'},
        {'id': '0007', 'len': 4, 'des': 'SMS消息重传次数'},
        #主服务器设置
        {'id': '0010', 'len': 0, 'des': '主服务器APN，无线通信拨号访问点/PPP拨号号码'},
        {'id': '0011', 'len': 0, 'des': '主服务器无线通信拨号用户名'},
        {'id': '0012', 'len': 0, 'des': '主服务器无线通信拨号密码'},
        {'id': '0013', 'len': 0, 'des': '主服务器地址，IP或域名'},
        {'id': '0014', 'len': 0, 'des': '备份服务器APN，无线通信拨号访问点'},
        {'id': '0015', 'len': 0, 'des': '备份服务器无线通信拨号用户名'},
        {'id': '0016', 'len': 0, 'des': '备份服务器无线通信拨号密码'},
        {'id': '0017', 'len': 0, 'des': '备份服务器地址，IP或域名'},
        {'id': '0018', 'len': 4, 'des': '服务器TCP端口'},
        {'id': '0019', 'len': 4, 'des': '服务器UDP端口'},
        {'id': '001A', 'len': 0, 'des': '道路运输IC卡认证备份服务器IP地址或域名，端口同住服务器'},
        {'id': '001B', 'len': 4, 'des': '道路运输证 IC 卡认证主服务器 TCP 端口'},
        {'id': '001C', 'len': 4, 'des': '道路运输证 IC 卡认证主服务器 UDP 端口'},
        {'id': '001D', 'len': 0, 'des': '道路运输证 IC 卡认证备份服务器 IP 地址或域名，端口同主服务器'},
        #位置回报参数设置
        {'id': '0020', 'len': 4, 'des': '位置汇报策略'},
        {'id': '0021', 'len': 4, 'des': '位置汇报方案'},
        {'id': '0022', 'len': 4, 'des': '驾驶员未登录汇报时间间隔'},
        {'id': '0027', 'len': 4, 'des': '休眠时汇报时间间隔'},
        {'id': '0028', 'len': 4, 'des': '紧急报警时汇报时间间隔'},
        {'id': '0029', 'len': 4, 'des': '缺省时间汇报间隔'},
        {'id': '002C', 'len': 4, 'des': '缺省距离汇报间隔'},
        {'id': '002D', 'len': 4, 'des': '驾驶员未登录汇报距离间隔'},
        {'id': '002E', 'len': 4, 'des': '休眠时汇报距离间隔'},
        {'id': '002F', 'len': 4, 'des': '紧急报警时汇报距离间隔'},
        {'id': '0030', 'len': 4, 'des': '拐点补传角度'},
        {'id': '0031', 'len': 2, 'des': '电子围栏半径（非法位移阈值）'},
        #电话设置
        {'id': '0040', 'len': 0, 'des': '监控平台电话号码'},
        {'id': '0041', 'len': 0, 'des': '复位电话号码'},
        {'id': '0042', 'len': 0, 'des': '恢复出厂设置电话号码'},
        {'id': '0043', 'len': 0, 'des': '监控平台 SMS 电话号码'},
        {'id': '0044', 'len': 0, 'des': '接收终端 SMS 文本报警号码'},
        {'id': '0045', 'len': 4, 'des': '终端电话接听策略'},
        {'id': '0046', 'len': 4, 'des': '每次最长通话时间'},
        {'id': '0047', 'len': 4, 'des': '当月最长通话时间'},
        {'id': '0048', 'len': 0, 'des': '监听电话号码'},
        {'id': '0049', 'len': 0, 'des': '监管平台特权短信号码'},
        #告警设置
        {'id': '0050', 'len': 4, 'des': '报警屏蔽字'},
        {'id': '0051', 'len': 4, 'des': '报警发送文本 SMS 开关'},
        {'id': '0052', 'len': 4, 'des': '报警拍摄开关'},
        {'id': '0053', 'len': 4, 'des': '报警拍摄存储标志'},
        {'id': '0054', 'len': 4, 'des': '关键标志'},
        {'id': '0055', 'len': 4, 'des': '最高速度(公里每小时，km/h）'},
        {'id': '0056', 'len': 4, 'des': '超速持续时间(秒,s)'},
        {'id': '0057', 'len': 4, 'des': '连续驾驶时间门限(秒,s)'},
        {'id': '0058', 'len': 4, 'des': '当天累计驾驶时间门限'},
        {'id': '0059', 'len': 4, 'des': '最小休息时间'},
        {'id': '005A', 'len': 4, 'des': '最长停车时间'},
        {'id': '005B', 'len': 2, 'des': '超速报警预警差值'},
        {'id': '005C', 'len': 2, 'des': '疲劳驾驶预警差值'},
        {'id': '005D', 'len': 2, 'des': '碰撞报警参数设置'},
        {'id': '005E', 'len': 2, 'des': '侧翻报警参数设置'},
        #拍照设置
        {'id': '0064', 'len': 4, 'des': '定时拍照控制'},
        {'id': '0065', 'len': 4, 'des': '定距拍照控制'},
        {'id': '0070', 'len': 4, 'des': '图像/视频质量'},
        {'id': '0071', 'len': 4, 'des': '亮度'},
        {'id': '0072', 'len': 4, 'des': '对比度'},
        {'id': '0073', 'len': 4, 'des': '饱和度'},
        {'id': '0074', 'len': 4, 'des': '色度'},
        #音视频设置参数表
        {'id': '0075', 'len': 21, 'des': '音视频参数设置'},
        {'id': '0076', 'len': 0, 'des': '音视频通道列表设置'},
        {'id': '0077', 'len': 0, 'des': '单独视频通道参数设置'},
        {'id': '0079', 'len': 4, 'des': '特殊报警录像参数设置'},
        {'id': '007A', 'len': 4, 'des': '视频相关报警屏蔽字'},
        {'id': '007B', 'len': 4, 'des': '图像分析报警参数设置'},
        {'id': '007C', 'len': 4, 'des': '终端休眠唤醒模式设置'},
        #车辆设置
        {'id': '0080', 'len': 4, 'des': '车辆里程表读数，1/10km'},
        {'id': '0081', 'len': 2, 'des': '车辆所在的省域 ID'},
        {'id': '0082', 'len': 2, 'des': '车辆所在的市域 ID'},
        {'id': '0083', 'len': 0, 'des': '公安交通管理部门颁发的机动车号牌'},
        {'id': '0084', 'len': 1, 'des': '车牌颜色'},
        #GNSS设置
        {'id': '0090', 'len': 1, 'des': 'GNSS 定位模式'},
        {'id': '0091', 'len': 1, 'des': 'GNSS 波特率'},
        {'id': '0092', 'len': 1, 'des': 'GNSS 模块详细定位数据输出频率'},
        {'id': '0093', 'len': 4, 'des': 'GNSS 模块详细定位数据采集频率'},
        {'id': '0094', 'len': 1, 'des': 'GNSS 模块详细定位数据上传方式'},
        {'id': '0095', 'len': 4, 'des': 'GNSS 模块详细定位数据上传设置'},
        #CAN总线设置
        {'id': '0100', 'len': 4, 'des': 'CAN 总线通道 1 采集时间间隔(ms)，0 表示不采集'},
        {'id': '0101', 'len': 2, 'des': 'CAN 总线通道 1 上传时间间隔(s)，0 表示不上传'},
        {'id': '0102', 'len': 4, 'des': 'CAN 总线通道 2 采集时间间隔(ms)，0 表示不采集'},
        {'id': '0103', 'len': 2, 'des': 'CAN 总线通道 2 上传时间间隔(s)，0 表示不上传'},
        {'id': '0110', 'len': 8, 'des': 'CAN 总线 ID 单独采集设置'},
        #0x0111--0x01ff         用于其他CAN总线ID单独采集设置
        #0xF000-0xFFFF          用户自定义
        {'id': 'F001', 'len': 2, 'des': '保留'},
        {'id': 'F002', 'len': 0, 'des': '保留'},
        {'id': 'F003', 'len': 10, 'des': '保留'},
        {'id': 'F004', 'len': 0, 'des': 'ECU绑定密码'},
        {'id': 'F005', 'len': 0, 'des': 'ECU解绑密码'},
        {'id': 'F006', 'len': 0, 'des': 'ECU固定密钥'},
        {'id': 'F007', 'len': 2, 'des': '时间间隔小时数','remark':'废止'},
        {'id': 'F008', 'len': 1, 'des': '贷款模式', 'remark': '读写'},
        {'id': 'F009', 'len': 1, 'des': '可插拔SIM卡联网控制', 'remark': '读写'},
        {'id': 'F00A', 'len': 1, 'des': '可插拔SIM卡换卡控制', 'remark': '读写'},
        {'id': 'F00B', 'len': 0, 'des': '可插拔SIM卡号码', 'remark': '读写'},
        {'id': 'F00C', 'len': 0, 'des': '贴片SIM卡号码', 'remark': '只读'},
        {'id': 'F00D', 'len': 2, 'des': '限制发动机转速阈值', 'remark': '读写'},
        {'id': 'F00E', 'len': 2, 'des': '块数据采集间隔', 'remark': '读写'},
        {'id': 'F00F', 'len': 2, 'des': '块数据汇报间隔', 'remark': '读写'},
        {'id': 'F010', 'len': 1, 'des': 'UDS 22服务器采集上报间隔1枚举序号', 'remark': '读写'},
        {'id': 'F011', 'len': 1, 'des': 'UDS 22服务器采集上报间隔2枚举序号', 'remark': '读写'},
        {'id': 'F012', 'len': 1, 'des': 'UDS 22服务器采集上报间隔3枚举序号', 'remark': '读写'},
        {'id': 'F101', 'len': 1, 'des': '普通超速阈值', 'remark': '读写'},
        {'id': 'F102', 'len': 1, 'des': '严重超时阈值', 'remark': '读写'},
        {'id': 'F103', 'len': 1, 'des': '急加速阈值', 'remark': '读写'},
        {'id': 'F104', 'len': 1, 'des': '急减速阈值', 'remark': '读写'},
        {'id': 'F105', 'len': 1, 'des': '发动机超转阈值', 'remark': '读写'},
        {'id': 'F106', 'len': 1, 'des': '急转弯阈值', 'remark': '读写'},
        {'id': 'F107', 'len': 1, 'des': '大油门行驶阈值', 'remark': '读写'},
        {'id': 'F108', 'len': 1, 'des': '机油压力阈值', 'remark': '读写'},
        {'id': 'F112', 'len': 1, 'des': '行驶载重计算次数最小值', 'remark': '读写'},
        {'id': 'F113', 'len': 1, 'des': '行驶载重计算值过滤百分比', 'remark': '读写'},
        {'id': 'F114', 'len': 1, 'des': '载重统计算法类型', 'remark': '读写'},
        {'id': 'F118', 'len': 1, 'des': '后桥速比', 'remark': '读写'},
        {'id': 'F119', 'len': 2, 'des': '轮胎直径', 'remark': '读写'},
        {'id': 'F120', 'len': 54, 'des': '变速箱速比', 'remark': '读写'},
        {'id': 'F124', 'len': 2, 'des': '发动机标定转速', 'remark': '读写'},
        {'id': 'F125', 'len': 2, 'des': '发动机标定功率', 'remark': '读写'}
    ]
    #报警标志位字符串
    alarm_data_str = ""
    Alarm_marker = ['紧急报警', '超速报警', '疲劳驾驶', '危险预警', 'GNSS模块发生故障', 'GNSS天线未接或被剪断', 'GNSS天线短路',
                    '终端电源欠压', '终端电源掉电', '终端LCD或显示器故障', 'TTS模块故障', '摄像头故障', '道路运输证IC卡模块故障',
                    '超速预警', '疲劳驾驶预警', '保留', '保留', '保留', '当天累计驾驶超时', '超时停车', '进出区域', '进出路线',
                    '路段驾驶时间不足/过长', '路线偏离报警', '车辆VSS故障', '车辆油量异常', '车辆被盗', '车辆非法点火',
                    '车辆非法位移', '碰撞预警', '侧翻预警', '非法开门']

    #定时拍照标志
    time_photo_control=['摄像通道 1 定时拍照开关标志','摄像通道 2 定时拍照开关标志','摄像通道 3 定时拍照开关标志',
                        '摄像通道 4 定时拍照开关标志','摄像通道 5 定时拍照开关标志','保留','保留','保留','摄像通道 1 定时拍照存储标志',
                        '摄像通道 2 定时拍照存储标志','摄像通道 3 定时拍照存储标志','摄像通道 4 定时拍照存储标志',
                        '摄像通道 5 定时拍照存储标志','保留','保留','保留','定时时间单位','定时时间间隔']
    #定距拍照标志
    disten_photo_control=['摄像通道 1 定距拍照开关标志','摄像通道 2 定距拍照开关标志','摄像通道 3 定距拍照开关标志',
                          '摄像通道 4 定距拍照开关标志','摄像通道 5 定距拍照开关标志','保留','保留','保留','摄像通道 1 定距拍照存储标志',
                          '摄像通道 2 定距拍照存储标志','摄像通道 3 定距拍照存储标志','摄像通道 4 定距拍照存储标志',
                          '摄像通道 5 定距拍照存储标志','保留','保留','保留','定距距离单位','定距距离间隔']
    #GNSS定位模式
    gnss_mode=['GPS定位','北斗定位','GLONASS定位','Galileo定位']
    #GNSS模块详细定位数据上传方式
    gnss_uplode="00"   
    #视频报警屏蔽字
    VideoAlarmInfo = ["保留", "保留", "保留", "保留", "保留", "保留", "保留", "保留", "保留", "保留", "保留", "保留", "保留", "保留", "保留", "保留",
                      "保留", "保留", "保留", "保留", "保留", "保留", "保留", "保留", "保留", "特殊报警录像达到存储阈值报警", "异常驾驶行为报警", "客车超员报警",
                      "其他视频设备故障报警", "存储单元故障报警", "视频信号遮挡报警", "视频信号丢失报警"]
    VideoAlarmStrInfo=''
    def LogicAisle(self, protocolStr, header):
        #参数总数
        par_total_num=int(protocolStr[0:self.par_total_num_len*2],16)
        print(par_total_num)
        header.append(self.analysisDescription[0] + str(par_total_num) + "\n")
        #截取参数列表字符串
        par_list_str=protocolStr[self.par_total_num_len*2:]
        s=par_list_str
        header.append("\n-------------------终端参数项列表--------------------\n")
        for i in range(par_total_num):
            par_id_str=s[0:self.parid_len*2]
            print(par_id_str)
            par_len=s[self.parid_len*2:(self.parid_len+self.par_len_str_len)*2]
            print(par_len)
            par_len=int(par_len,16)
            for par in self.par_list:
                if "0000"+par['id'] == par_id_str.upper():
                    par_val=s[(self.parid_len+self.par_len_str_len)*2:(self.parid_len+self.par_len_str_len+par_len)*2]
                    print(par_val)
                    par_des=par['des']
                    #时间，单位秒
                    if par['id']=="0001" or par['id']=="0002" or par['id']=="0004" or par['id']=="0006" or \
                            par['id']=="0022" or par['id']=="0027" or par['id']=="0028" or par['id']=="0029" or \
                            par['id']=="0056" or par['id']=="0057" or par['id']=="0058" or par['id']=="0059" or \
                            par['id'] == "005A" or par['id']=="005C" or par['id']=="0093":
                        par_val=self.hex_to_dec(par_val)
                        header.append(par_des+": "+par_val+"s\n")
                    #通话时间
                    elif par['id']=="0046" or par['id']=="0047":
                        if par_val=="00000000":
                            header.append(par_des+": "+"不允许通话"+"\n")
                        elif par_val=="ffffffff":
                            header.append(par_des+": "+"不限制"+"\n")
                        else:
                            par_val=self.hex_to_dec(par_val)
                            header.append(par_des+": "+par_val+"s\n")
                    #tcp/udp 端口
                    #角度
                    #次数
                    #图像/视频质量，亮度，对比度，饱和度，色度
                    #车辆省域ID，车辆市域ID，车牌颜色
                    elif par['id']=="0003" or par['id']=="0005" or par['id']=="0007" or par['id']=="0018" or \
                            par['id']=="0019" or par['id']=="001B" or par['id']=="001C" or par['id']=="0030" or \
                            par['id']=="005E" or par['id']=="0070" or par['id']=="0071" or par['id']=="0072" or \
                            par['id']=="0073" or par['id']=="0074" or par['id']=="0081" or par['id']=="0082" or \
                            par['id']=="0084" :
                        par_val = self.hex_to_dec(par_val)
                        header.append(par_des + ": " + par_val + "\n")
                    #GBK解码(电话,机动车牌号)
                    elif par['id']=="0010" or par['id']=="0011" or par['id']=="0012" or par['id']=="0013" or \
                            par['id']=="0014" or par['id']=="0015" or par['id']=="0016" or par['id']=="0017" or \
                            par['id']=="001A" or par['id']=="001B" or par['id']=="001C" or par['id']=="001D" or \
                            par['id']=="0040" or par['id']=="0041" or par['id']=="0042" or par['id']=="0043" or \
                            par['id']=="0044" or par['id']=="0048" or par['id']=="0049" or par['id']=="0083" :
                        par_val = par_val.decode("hex").decode('gb2312')
                        header.append(par_des + ": " + par_val + "\n")
                    #位置汇报策略
                    elif par['id']=="0020":#0：定时汇报；1：定距汇报；2：定时和定距汇报
                        par_val=int(par_val,16)
                        if par_val==0:
                            header.append(par_des + ": " + str(par_val) + " 定时汇报" + "\n")
                        elif par_val==1:
                            header.append(par_des + ": " + str(par_val) + " 定距汇报" + "\n")
                        elif par_val==2:
                            header.append(par_des + ": " + str(par_val) + " 定时汇报和定距汇报" + "\n")
                    # 位置汇报方案
                    elif par['id']=="0021":#，0：根据 ACC 状态； 1：根据登录状态和 ACC 状态，先判断登录状态，若登录再根据 ACC 状态
                        par_val = int(par_val, 16)
                        if par_val==0:
                            header.append(par_des + ": " + str(par_val) + " 根据ACC状态" + "\n")
                        elif par_val==1:
                            header.append(par_des + ": " + str(par_val) + " 根据ACC状态和登录状态" + "\n")
                    #距离，米
                    elif par['id']=="002C" or par['id']=="002D" or par['id']=="002E" or par['id']=="002F" or \
                            par['id']=="0031" :
                        par_val=self.hex_to_dec(par_val)
                        header.append(par_des+": "+par_val+"m\n")
                    #终端电话接听策略
                    elif par['id']=="0045":
                        par_val = int(par_val, 16)
                        if par_val == 0:
                            header.append(par_des + ": " + str(par_val) + " 自动接听" + "\n")
                        elif par_val == 1:
                            header.append(par_des + ": " + str(par_val) + " ACC ON时自动接听" + "\n")
                        elif par_val == 2:
                            header.append(par_des + ": " + str(par_val) + " OFF时手动接听" + "\n")
                    #报警标志
                    elif par['id']=="0050" or par['id']=="0051" or par['id']=="0052" or par['id']=="0053" or par['id']=="0054" :
                        par_val=self.hex_to_bin(par_val,par_len*8)
                        print(par_val)
                        header.append(par_des + ": "  + par_val + "\n")
                        self.set_alarm_num(par_val, header)
                    #速度
                    elif par['id']=="0055":#km/h
                        par_val=int(par_val,16)
                        header.append(par_des+": "+ str(par_val) + "km/h\n")
                    elif par['id']=="005B" or par['id']=="0080" :#o.1km/h
                        par_val = int(par_val, 16)*0.1
                        header.append(par_des + ": " + str(par_val) + "km/h\n")
                    #碰撞报警参数
                    elif par['id']=="005D":
                        #碰撞时间
                        collision_t=int(par_val[2:],16)*4
                        #碰撞加速度
                        collision_a=int(par_val[0:2],16)*0.1
                        header.append(par_des + ": " + "碰撞时间："+ str(collision_t) + "ms 碰撞加速度：" + str(collision_a) +"g\n")
                    #定时拍照标志
                    elif par['id']=="0064":
                        par_val=self.hex_to_bin(par_val,par_len*8)
                        header.append(par_des+": "+ par_val +"\n")
                        self.set_time_photo_control(par_val,header)
                    # 定距拍照标志
                    elif par['id'] == "0065":
                        par_val = self.hex_to_bin(par_val,par_len*8)
                        header.append(par_des + ": " + par_val + "\n")
                        self.set_disten_photo_control(par_val, header)
                    #GNSS定位模式
                    elif par['id']=="0090":
                        par_val=self.hex_to_bin(par_val,par_len*8)
                        count=8
                        header.append(par_des+": "+par_val+"\n")
                        for k in range(count):
                            if k>3:
                                pass
                            else:
                                gnss_bit=par_val[count-1:count]
                                if gnss_bit=="1":
                                    header.append("启用"+self.gnss_mode[k]+"\n")
                                elif gnss_bit=="0":
                                    header.append("禁用" + self.gnss_mode[k] + "\n")
                            count -=1
                    #GNSS波特率
                    elif par['id']=="0091":
                        msg=""
                        if par_val=="00":
                            msg="4800"
                        elif par_val=="01":
                            msg="9600"
                        elif par_val=="02":
                            msg="19200"
                        elif par_val=="03":
                            msg="38400"
                        elif par_val=="04":
                            msg="57600"
                        elif par_val=="05":
                            msg="115200"
                        header.append(par_des+": "+msg+"\n")
                    #GNSS模块详细定位数据输出频率
                    elif par['id']=="0092":
                        msg=""
                        if par_val=="00":
                            msg="500ms"
                        elif par_val=="01":
                            msg="1000ms(默认值）"
                        elif par_val=="02":
                            msg="2000ms"
                        elif par_val=="03":
                            msg="3000ms"
                        elif par_val=="04":
                            msg="4000ms"
                        header.append(par_des+": "+msg+"\n")
                    #GNSS模块详细定位数据上传方式
                    elif par['id']=="0094":
                        self.gnss_uplode = par_val
                        msg=""
                        if par_val=="00":  msg="本地存储，不上传（默认值）"
                        elif par_val=="01": msg="按时间间隔上传"
                        elif par_val=="02": msg="按距离间隔上传"
                        elif par_val.upper()=="0B": msg="按累计时间上传，达到传输时间后自动停止上传"
                        elif par_val.upper()=="0C": msg="按累计距离上传，达到距离后自动停止上传"
                        elif par_val.upper() == "0D": msg = "按累计条数上传，达到上传条数后自动停止上传"
                        header.append(par_des+": "+msg+"\n")
                    # GNSS模块详细定位数据上传设置
                    elif par['id'] == "0095":
                        par_val=self.hex_to_dec(par_val)
                        msg=""
                        if self.gnss_uplode == "01":
                            msg = par_val+"s"
                        elif self.gnss_uplode == "02":
                            msg = par_val+"m"
                        elif self.gnss_uplode.upper() == "0B":
                            msg = par_val+"s"
                        elif self.gnss_uplode.upper() == "0C":
                            msg = par_val+"m"
                        elif self.gnss_uplode.upper() == "0D":
                            msg = par_val+"条"
                        header.append(par_des + ": " + msg + "\n")
                    #CAN采集时间间隔，时间，ms
                    elif par['id']=="0100" or par['id']=="0102" :
                        par_val=self.hex_to_dec(par_val)
                        header.append(par_des+": "+par_val+"ms\n")
                    #CAN总线ID单独采集设置
                    elif par['id']=="0110":
                        par_val=self.hex_to_bin(par_val,par_len*8)
                        self.set_CAN_id(par_val,header)
                    #时间间隔小时数FT
                    elif par['id']=="F007":
                        par_val = self.hex_to_dec(par_val)
                        header.append(par_des + ": " + par_val + par['remark'] +"\n")
                    #贷款模式
                    elif par['id']=="F008":
                        msg = ''
                        if par_val == "00":
                            msg = '：未知'
                        elif par_val == "01":
                            msg = '：非贷款车'
                        elif par_val == "02":
                            msg = '：福田自营贷款车'
                        elif par_val == "03":
                            msg = '：非自营贷款车'
                        header.append(par_des+": "+par_val+msg+par['remark']+'\n')
                    #可插拔SIM卡联网控制
                    elif par['id']=="F008":
                        msg = ''
                        if par_val == "00":
                            msg = '：可以正常连接'
                        elif par_val == "01":
                            msg = '：无法进行连接'
                        header.append(par_des+": " +par_val+msg+par['id']+'\n')
                    #可插拔SIM卡换卡控制
                    elif par['id']=="F008":
                        msg = ''
                        if par_val == "00":
                            msg = '：可以正常换卡'
                        elif par_val == "01":
                            msg = '：无法进行换卡'
                        header.append(par_des+": " + par_val + msg + par['id'] + '\n')
                    #快数据采集/汇报间隔
                    elif par['id']=="F00E" or par['id']=="F00F":
                        header.append(par_des + ":" + par['remark'] + '\n')
                        header.append("块ID："+par_val[:2]+'\n')
                        header.append("间隔枚举序号：" + par_val[2:4] + '\n')
                    #音视频参数定义及说明
                    elif par['id']=="0075":
                        moshi=int(par_val[0],16)
                        if moshi==0: msg=':CBR(固定码率)'
                        elif moshi==1: msg=':VBR（可变码率）'
                        elif  moshi==2: msg=':ABR（平均码率）'
                        elif moshi>=100 and moshi<=127: msg='：自定义'
                        else: msg=''
                        header.append('实时流编码模式：'+str(moshi)+msg+'\n')
                        fbl=int(par_val[1],16)
                        if fbl==0: msg=':QCIF'
                        elif fbl==1: msg=':CIF'
                        elif fbl==2: msg=':WCIF'
                        elif fbl==3: msg=':Dl'
                        elif fbl==4: msg=':WDI'
                        elif fbl==5: msg=':720p'
                        elif fbl==6: msg=':1080p'
                        elif (fbl >= 100 and fbl <= 127): msg='：自定义'
                        else: msg=''
                        header.append('实时流编码分辨率：'+str(fbl)+msg+'\n')
                        jiange=int(par_val[2:4],16)
                        header.append('实时流关键帧间隔：'+str(jiange)+'帧\n')
                        zhenlv=int(par_val[4],16)
                        header.append('实时流目标帧率：'+str(zhenlv)+'帧/s\n')
                        malv=int(par_val[5:9],16)
                        header.append('实时流目标码率：'+str(malv)+'kbps\n')

                        moshi2 = int(par_val[9], 16)
                        if moshi2 == 0:
                            msg = ':CBR(固定码率)'
                        elif moshi2 == 1:
                            msg = ':VBR（可变码率）'
                        elif moshi2 == 2:
                            msg = ':ABR（平均码率）'
                        elif moshi2 >= 100 and moshi2 <= 127:
                            msg = '：自定义'
                        else:
                            msg = ''
                        header.append('存储流编码模式：' + str(moshi2) + msg + '\n')
                        fbl2 = int(par_val[10], 16)
                        if fbl2 == 0:
                            msg = ':QCIF'
                        elif fbl2 == 1:
                            msg = ':CIF'
                        elif fbl2 == 2:
                            msg = ':WCIF'
                        elif fbl2 == 3:
                            msg = ':Dl'
                        elif fbl2 == 4:
                            msg = ':WDI'
                        elif fbl2 == 5:
                            msg = ':720p'
                        elif fbl2 == 6:
                            msg = ':1080p'
                        elif (fbl2 >= 100 and fbl2 <= 127):
                            msg = '：自定义'
                        else:
                            msg = ''
                        header.append('存储流编码分辨率：' + str(fbl2) + msg + '\n')
                        jiange2 = int(par_val[11:13], 16)
                        header.append('存储流关键帧间隔：' + str(jiange2) + '帧\n')
                        zhenlv2 = int(par_val[13], 16)
                        header.append('存储流目标帧率：' + str(zhenlv2) + '帧/s\n')
                        malv2 = int(par_val[14:18], 16)
                        header.append('存储流目标码率：' + str(malv2) + 'kbps\n')

                        osd= self.hex_to_bin(par_val[18:20],2)
                        print osd
                        header.append('OSD字母叠加设置：'+par_val[18:20]+'\n')
                        osd_list=['日期和时间','车牌号码','逻辑通道号','经纬度','行驶记录速度','卫星定位速度','连续驾驶时间'
                            ,'保留','保留','保留','保留','自定义','自定义','自定义','自定义','自定义']
                        for i in range(16):
                            print i
                            if osd[i]=='1': header.append(osd_list[15-i]+'\n')
                        output=par_val[20]
                        if output=='00': msg='不启用'
                        elif output=='01': msg='启用'
                        else : msg=''
                        header.append('是否启用音频输出：'+output+msg+'\n')
                    #音视频通道列表
                    elif par['id']=="0076":
                        td_total=int(par_val[0:2],16)
                        header.append('音视频通道总数：'+str(td_total)+'\n')
                        total_1=int(par_val[2:4])
                        header.append('音频通道总数：' + str(total_1) + '\n')
                        total_2 = int(par_val[4:6])
                        header.append('视频通道总数：' + str(total_2) + '\n')
                        header.append('音视频通道对照表：\n')
                        total=td_total+total_1+total_2#1+m+n
                        count=6
                        for i in range(total):
                            table=par_val[count:count+8]
                            count+=8
                            header.append('物理通道号：'+table[0:2]+'\n'+'逻辑通道号：'+table[2:4]+'\n'+'通道类型：'+table[4:6]+'（0：音视频；1：音频；2：视频）\n')
                            if table[4:6]=='00' or table[4:6]=='02': msg=' 有效 '
                            else: msg=''
                            header.append('是否连接云台：'+msg+table[6:8]+'(0:未连接；1:连接)\n')
                    #单独视频通道列表设置
                    elif par['id']=='0077':
                        td_count=int(par_val[0:2],16)
                        header.append('需单独设置视频参数的通道数量：'+str(td_count)+'\n')
                        c=2
                        for i in range(td_count):
                            table=par_val[c:c+42]
                            header.append('逻辑通道号：'+table+'\n')
                            
                            moshi = int(table[2:4], 16)
                            if moshi == 0:
                                msg = ':CBR(固定码率)'
                            elif moshi == 1:
                                msg = ':VBR（可变码率）'
                            elif moshi == 2:
                                msg = ':ABR（平均码率）'
                            elif moshi >= 100 and moshi <= 127:
                                msg = '：自定义'
                            else:
                                msg = ''
                            header.append('实时流编码模式：' + str(moshi) + msg + '\n')
                            fbl = int(table[4:6], 16)
                            if fbl == 0:
                                msg = ':QCIF'
                            elif fbl == 1:
                                msg = ':CIF'
                            elif fbl == 2:
                                msg = ':WCIF'
                            elif fbl == 3:
                                msg = ':Dl'
                            elif fbl == 4:
                                msg = ':WDI'
                            elif fbl == 5:
                                msg = ':720p'
                            elif fbl == 6:
                                msg = ':1080p'
                            elif (fbl >= 100 and fbl <= 127):
                                msg = '：自定义'
                            else:
                                msg = ''
                            header.append('实时流编码分辨率：' + str(fbl) + msg + '\n')
                            jiange = int(table[6:10], 16)
                            header.append('实时流关键帧间隔：' + str(jiange) + '帧\n')
                            zhenlv = int(table[10:12], 16)
                            header.append('实时流目标帧率：' + str(zhenlv) + '帧/s\n')
                            malv = int(table[12:20], 16)
                            header.append('实时流目标码率：' + str(malv) + 'kbps\n')

                            moshi2 = int(table[20:22], 16)
                            if moshi2 == 0:
                                msg = ':CBR(固定码率)'
                            elif moshi2 == 1:
                                msg = ':VBR（可变码率）'
                            elif moshi2 == 2:
                                msg = ':ABR（平均码率）'
                            elif moshi2 >= 100 and moshi2 <= 127:
                                msg = '：自定义'
                            else:
                                msg = ''
                            header.append('存储流编码模式：' + str(moshi2) + msg + '\n')
                            fbl2 = int(table[22:24], 16)
                            if fbl2 == 0:
                                msg = ':QCIF'
                            elif fbl2 == 1:
                                msg = ':CIF'
                            elif fbl2 == 2:
                                msg = ':WCIF'
                            elif fbl2 == 3:
                                msg = ':Dl'
                            elif fbl2 == 4:
                                msg = ':WDI'
                            elif fbl2 == 5:
                                msg = ':720p'
                            elif fbl2 == 6:
                                msg = ':1080p'
                            elif (fbl2 >= 100 and fbl2 <= 127):
                                msg = '：自定义'
                            else:
                                msg = ''
                            header.append('存储流编码分辨率：' + str(fbl2) + msg + '\n')
                            jiange2 = int(table[24:28], 16)
                            header.append('存储流关键帧间隔：' + str(jiange2) + '帧\n')
                            zhenlv2 = int(table[28:30], 16)
                            header.append('存储流目标帧率：' + str(zhenlv2) + '帧/s\n')
                            malv2 = int(table[30:38], 16)
                            header.append('存储流目标码率：' + str(malv2) + 'kbps\n')

                            osd = self.hex_to_bin(table[38:42], 2)
                            header.append('OSD字母叠加设置：' + table[38:42] + '\n')
                            osd_list = ['日期和时间', '车牌号码', '逻辑通道号', '经纬度', '行驶记录速度', '卫星定位速度', '连续驾驶时间'
                                , '保留', '保留', '保留', '保留', '自定义', '自定义', '自定义', '自定义', '自定义']
                            for j in range(16):
                                if osd[j] == '1': header.append(osd_list[15 - j] + '\n')
                    #特殊报警录像参数设置
                    elif par['id']=='0079':
                        s=par_val[0:2]
                        header.append('特殊报警录像存储阈值：'+s+'\n')
                        s=str(int(par_val[2:4],16))
                        header.append('特殊报警录像持续时间：' + s + ' min \n')
                        s=str(int(par_val[4:6],16))
                        header.append('特殊报警标识起始时间：' + s + ' min \n')
                    #视频相关报警屏蔽字
                    elif par['id']=='007A':
                        self.AnalysisVideoAlarmFlagBits(par_val,header)
                    #图像报警参数设置
                    elif par['id']=='007B':
                        s=int(par_val[0:2],16)
                        header.append('车辆核载人数：'+str(s)+'\n')
                        s=par_val[2:4]
                        header.append('疲劳程度阈值：'+s+'\n')
                    #终端休眠唤醒模式设置
                    elif par['id']=='007C':
                        s0=self.hex_to_bin(par_val[0:2],1)
                        header.append('休眠唤醒模式：0表示不设置，1表示设置\n')
                        if s0[7]=='1': header.append('条件唤醒\n')
                        if s0[6]=='1': header.append('定时唤醒\n')
                        if s0[5]=='1': header.append('手动唤醒\n')
                        s1=self.hex_to_bin(par_val[2:4],1)
                        header.append('唤醒条件设置：0表示不设置，1表示设置\n')
                        if s0[7]=='1':
                            if s1[7]=='1': header.append('紧急报警\n')
                            if s1[6]=='1': header.append('碰撞侧翻报警\n')
                            if s1[5] == '1': header.append('车辆开门\n')
                        s2=self.hex_to_bin(par_val[4:6],1)
                        header.append('定时唤醒日设置：0表示不设置，1表示设置\n')
                        if s2[7] == '1': header.append('周一\n')
                        if s2[6] == '1': header.append('周二\n')
                        if s2[5] == '1': header.append('周三\n')
                        if s2[4] == '1': header.append('周四\n')
                        if s2[3] == '1': header.append('周五\n')
                        if s2[2] == '1': header.append('周六\n')
                        if s2[1] == '1': header.append('周日\n')
                        s3=par_val[6:40]
                        biaozhi=self.hex_to_bin(s3[0:2],1)
                        header.append('定时唤醒启用标志：0表示不设置，1表示设置\n')
                        if biaozhi[3] == '1': header.append('时间段1唤醒时间启用\n')
                        if biaozhi[2] == '1': header.append('时间段2唤醒时间启用\n')
                        if biaozhi[1] == '1': header.append('时间段3唤醒时间启用\n')
                        if biaozhi[0] == '1': header.append('时间段4唤醒时间启用\n')
                        time_list=['时间段1唤醒时间','时间段1关闭时间','时间段2唤醒时间','时间段2关闭时间','时间段3唤醒时间'
                            ,'时间段3关闭时间','时间段4唤醒时间','时间段4关闭时间']
                        count_time=2
                        for i in range(8):
                            time=s3[count_time:count_time+4]
                            count_time+=4
                            header.append(time_list[i]+':'+time[0:2]+':'+time[2:4]+'\n')
                    else:
                        if int(par_id_str,16)>=61441 and int(par_id_str,16)<=61728:
                            header.append(par_des + ": " + par_val + par['remark'] + "\n")
                        else:
                            header.append(par_des + ": " + par_val + "\n")
                    s=s[(self.parid_len+self.par_len_str_len+par_len)*2:]
        self.result=header

    def hex_to_dec(self,par_val):
        val=str(int(par_val,16))
        return val

    def set_alarm_num(self, s, header):
        count = 32
        alarm_data_list = []
        self.alarm_data_str = s
        
        for i in range(count):
            alarm_data = self.alarm_data_str[count - 1:count]
            if alarm_data == "1":
                if i == 15 or i == 16 or i == 17:
                    pass
                else:
                    header.append(self.Alarm_marker[i] + '\n')
            alarm_data_list.append(alarm_data)
            count -= 1

    def set_time_photo_control(self,s,header):
        count=32
        for i in range(count):
            time_photo_control_bit=s[count-1:count]
            if i==5 or i==6 or i==7 or i==13 or i==14 or i==15:
                    pass
            else:
                if time_photo_control_bit=="1":
                    if (i>= 0) and (i <= 4) :
                        header.append(self.time_photo_control[i]+": 允许"+"\n")
                    elif i>=8 and i<=12 :
                        header.append(self.time_photo_control[i] + ": 上传" + "\n")
                    elif i==16:
                        header.append(self.time_photo_control[i] + ": 分" + "\n")
                else :
                    if i>= 0and i <= 4 :
                        header.append(self.time_photo_control[i]+": 不允许"+"\n")
                    elif i>=8and i<=12 :
                        header.append(self.time_photo_control[i] + ": 存储" + "\n")
                    elif i==16:
                        header.append(self.time_photo_control[i] + ": 秒" + "\n")
            count-=1
        #定时时间间隔，受到参数设置或重新启动后执行 
        time_cell=int(s[0:15],2)
        header.append(self.time_photo_control[17] + ": " + str(time_cell) + "\n")
    def set_disten_photo_control(self, s, header):
        count = 32
        for i in range(count):
            time_photo_control_bit = s[count - 1:count]
            if i == 5 or i == 6 or i == 7 or i == 13 or i == 14 or i == 15:
                pass
            else:
                if time_photo_control_bit == "1":
                    if (i >= 0) and (i <= 4):
                        header.append(self.time_photo_control[i] + ": 允许" + "\n")
                    elif i >= 8 and i <= 12:
                        header.append(self.time_photo_control[i] + ": 上传" + "\n")
                    elif i == 16:
                        header.append(self.time_photo_control[i] + ": 公里" + "\n")
                else:
                    if i >= 0 and i <= 4:
                        header.append(self.time_photo_control[i] + ": 不允许" + "\n")
                    elif i >= 8 and i <= 12:
                        header.append(self.time_photo_control[i] + ": 存储" + "\n")
                    elif i == 16:
                        header.append(self.time_photo_control[i] + ": 米" + "\n")
            count -= 1
        # 定距距离间隔，受到参数设置或重新启动后执行
        disten_cell = int(s[0:15], 2)
        header.append(self.disten_photo_control[17] + ": " + str(disten_cell) + "\n")

    def hex_to_bin(self,s,s_len):
        s = bin(int(s, 16))
        s = s[2:]
        s = s.zfill(s_len)
        return s

    def set_CAN_id(self,s,header):
        #采集时间
        acq_time=int(s[32:],16)
        #CAN通道号
        nchan=s[31]
        #帧类型
        frame_type=s[30]
        #数据采集方式
        acq_type=s[29]
        #总线ID
        trunk_id=int(s[0:29],16)
        header.append("此ID采集时间间隔："+str(acq_time)+"\n")
        if nchan=="0":
            header.append("CAN通道号：CAN1\n")
        elif nchan=="1":
            header.append("CAN通道号：CAN2\n")
        if frame_type=="0":
            header.append("帧类型：标准帧\n")
        elif frame_type=="1":
            header.append("帧类型：扩展帧\n")
        if acq_type=="0":
            header.append("数据采集方式：原始数据\n")
        elif acq_type=="1":
            header.append("数据采集方式：采集区间的计算值\n")
        header.append("CAN总线ID："+str(trunk_id)+'\n')
    def AnalysisVideoAlarmFlagBits(self, source, header):
        print("AnalysisVideoAlarmFlagBits.source=%s" % source)
        print type(source)
        # chars = array.array( 'u', source );
        # char[] chars = source.toCharArray();
        chars = list(source)
        print type(chars)
        print("AnalysisVideoAlarmFlagBits.chars=%s" % chars[2])
        print("AnalysisVideoAlarmFlagBits.chars=%d" % len(chars))
        k = True
        for i in range(len(chars)):
            print("AnalysisVideoAlarmFlagBits.chars=%s" % chars[i])
            if (chars[i] == '1'):
                self.VideoAlarmAnaly(i)
                k = False

        if (k):
            self.VideoAlarmStrInfo = "无 \n"
        header.append("视频相关报警：" + self.VideoAlarmStrInfo + "\n")

    def VideoAlarmAnaly(self, num):
        if (self.VideoAlarmInfo[num] != "保留"):
            self.VideoAlarmStrInfo += self.VideoAlarmInfo[num]
            self.VideoAlarmStrInfo += "; \n"
